home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume11 / xdvi / patch11.02 < prev    next >
Encoding:
Internet Message Format  |  1991-02-12  |  44.2 KB
  1. Path: uunet!olivea!apple!sun-barr!newstop!exodus!math.berkeley.edu
  2. From: vojta@math.berkeley.edu (Paul Vojta)
  3. Newsgroups: comp.sources.x
  4. Subject: v11i060: xdvi, Patch11, Part02/02
  5. Message-ID: <7930@exodus.Eng.Sun.COM>
  6. Date: 13 Feb 91 07:10:26 GMT
  7. References: <csx-11i059:xdvi@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1414
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: vojta@math.berkeley.edu (Paul Vojta)
  13. Posting-number: Volume 11, Issue 60
  14. Archive-name: xdvi/patch11.02
  15. Patch-To: xdvi: Volume 3, Issues 37-39
  16. Patch-To: xdvi: Volume 4, Issue 44 (xdvi, Patch4)
  17. Patch-To: xdvi: Volume 4, Issue 96 (xdvi, dvi previewer, Patch5)
  18. Patch-To: xdvi: Volume 5, Issue 35 (xdvi, dvi previewer, patch 6, part 1/2)
  19. Patch-To: xdvi: Volume 5, Issue 36 (xdvi, dvi previewer, patch 6, part 2/2)
  20. Patch-To: xdvi: Volume 6, Issue  5 (xdvi, Patch7)
  21. Patch-To: xdvi: Volume 6, Issue 49 (xdvi, dvi previewer, patch 8)
  22. Patch-To: xdvi: Volume 7, Issue 52 (xdvi, dvi previewer, patch 9, part 1/2)
  23. Patch-To: xdvi: Volume 7, Issue 53 (xdvi, dvi previewer, patch 9, part 2/2)
  24. Patch-To: xdvi: Volume 10, Issue 9 (xdvi, patch10, part01/02)
  25. Patch-To: xdvi: Volume 10, Issue 10 (xdvi, patch10, part02/02)
  26.  
  27. -- cut here --
  28. diff -cr old/pxl_open.c new/pxl_open.c
  29. *** old/pxl_open.c    Sun Oct 21 14:47:37 1990
  30. --- new/pxl_open.c    Sat Feb  2 16:28:32 1991
  31. ***************
  32. *** 1,5 ****
  33.   /*
  34. !  *    pxl_open.c(font, font_ret, mag, mag_ret, factor, name)
  35.    *    Find and open gf, pk, or pxl files in the given path, having the given
  36.    *    name and magnification.  It tries gf files first, followed by pk and pxl
  37.    *    files.  The path variable should be of the form path1:path2:...:pathn,
  38. --- 1,5 ----
  39.   /*
  40. !  *    pxl_open.c(font, font_ret, mag, mag_ret, name)
  41.    *    Find and open gf, pk, or pxl files in the given path, having the given
  42.    *    name and magnification.  It tries gf files first, followed by pk and pxl
  43.    *    files.  The path variable should be of the form path1:path2:...:pathn,
  44. ***************
  45. *** 11,23 ****
  46.    *    and if it fails then the procedure will try changing the point size
  47.    *    as well.  If all of the above fails, then alt_font will be tried.
  48.    *
  49.    *    If the file is found, then a file pointer is returned, and the following
  50.    *    values are set:
  51.    *        *font_ret  a pointer to a string containing the font name (if
  52.    *            different from the font requested).
  53.    *        *mag_ret  the actual magnification found.
  54. -  *        *factor    the ratio of the point sizes of the requested font
  55. -  *            and the font actually found (or 1.0 if altfont is used).
  56.    *        *name    a pointer to a string containing the file name
  57.    *
  58.    *    If the file is not found, then the return value is NULL.
  59. --- 11,30 ----
  60.    *    and if it fails then the procedure will try changing the point size
  61.    *    as well.  If all of the above fails, then alt_font will be tried.
  62.    *
  63. +  *    If the variable SEARCH_SUBDIRECTORIES is set, then the environment
  64. +  *    variable TEXFONTS_SUBDIR and the #define variable DEFAULT_SUBDIR_PATH
  65. +  *    will be enabled, as well as ``*'' and ``**'' specifiers.  The
  66. +  *    SUBDIR_PATH things will be appended to the end of the usual path, with
  67. +  *    a `*' at the end of each component.  The `*' means that subdirectories
  68. +  *    will be searched up to one level; `**' means that subdirectories
  69. +  *    will be recursively searched to any level.  Neither specifier may be
  70. +  *    preceded by a `%' specifier (after the most recent colon).
  71. +  *
  72.    *    If the file is found, then a file pointer is returned, and the following
  73.    *    values are set:
  74.    *        *font_ret  a pointer to a string containing the font name (if
  75.    *            different from the font requested).
  76.    *        *mag_ret  the actual magnification found.
  77.    *        *name    a pointer to a string containing the file name
  78.    *
  79.    *    If the file is not found, then the return value is NULL.
  80. ***************
  81. *** 49,65 ****
  82.   
  83.   static    char    *font_path;
  84.   static    char    *default_font_path    = DEFAULT_FONT_PATH;
  85.   static    int    *sizes, *sizend;
  86.   static    char    default_size_list[]    = DEFAULT_FONT_SIZES;
  87.   
  88.   #ifdef    sun
  89.   char    *sprintf();
  90.   #endif
  91.   
  92. ! char    *malloc(), *getenv();
  93.   double    atof();
  94.   
  95.   static    void
  96.   get_sizes(size_list, spp)
  97.       char    *size_list;
  98.       int    **spp;
  99. --- 56,306 ----
  100.   
  101.   static    char    *font_path;
  102.   static    char    *default_font_path    = DEFAULT_FONT_PATH;
  103. + #ifdef    SEARCH_SUBDIRECTORIES
  104. + static    char    default_subdir_path[]    = DEFAULT_SUBDIR_PATH;
  105. + #endif
  106.   static    int    *sizes, *sizend;
  107.   static    char    default_size_list[]    = DEFAULT_FONT_SIZES;
  108.   
  109. + #define    FILENAMESIZE 512
  110. + 
  111.   #ifdef    sun
  112.   char    *sprintf();
  113.   #endif
  114.   
  115. ! char    *xmalloc(), *getenv();
  116.   double    atof();
  117. + void    exit();
  118.   
  119. + #ifdef    SEARCH_SUBDIRECTORIES
  120. + /* We will need some system include files to deal with directories.  */
  121. + /* <sys/types.h> was included by xdvi.h.  */
  122. + #include <sys/stat.h>
  123. + 
  124. + static    int    is_dir ();
  125. + 
  126. + #if    defined(SYSV) || defined(_POSIX_SOURCE)
  127. + #include <dirent.h>
  128. + typedef struct dirent *directory_entry_type;
  129. + #else
  130. + #include <sys/dir.h>
  131. + typedef struct direct *directory_entry_type;
  132. + #endif
  133. + 
  134. + /* Declare the routine to get the current working directory.  */
  135. + 
  136. + #ifdef    HAVE_GETWD
  137. + extern char *getwd ();
  138. + #define    getcwd(b, len)    ((b) ? getwd (b) : getwd (xmalloc (len, "getwd")))
  139. + #else
  140. + #ifdef    ANSI
  141. + extern char *getcwd (char *, int);
  142. + #else
  143. + extern char *getcwd ();
  144. + #endif    /* not ANSI */
  145. + #endif    /* not HAVE_GETWD */
  146. + 
  147. + char    *cwd;
  148. + 
  149. + /* The following is a data structure containing the precomputed names of
  150. +    subdirectories to be recursively searched. */
  151. + 
  152. + static    struct subdir_entry {
  153. +     char    *name;        /* partial string */
  154. +     char    *index;        /* reference point in {,default_}font_path */
  155. +     struct subdir_entry *next;    /* link in list */
  156. + }
  157. +     *subdir_head    = NULL,
  158. +     *next_subdir;
  159. + 
  160. + #ifndef    S_ISDIR
  161. + #define    S_ISDIR(m)    ((m & S_IFMT) == S_IFDIR)
  162. + #endif
  163. + 
  164. + /* Return true if FN is a directory or a symlink to a directory,
  165. +    false if not. */
  166. + 
  167. + static    int
  168. + is_dir (fn)
  169. +   char *fn;
  170. + {
  171. +   struct stat stats;
  172. + 
  173. +   return stat (fn, &stats) == 0 && S_ISDIR (stats.st_mode);
  174. + }
  175. + 
  176. + /*
  177. +  *    Compute extra length of subdirectory entries, including a star for each.
  178. +  */
  179. + 
  180. + static    int
  181. + extra_len(str1, str2)
  182. +     char *str1, *str2;
  183. + {
  184. +     int    bias    = 0;
  185. +     char    *p    = str1;
  186. +     char    *q;
  187. + 
  188. +     do {
  189. +         q = index(p, PATH_SEP);
  190. +         if (q == NULL) q = p + strlen(p);
  191. +         if (q == p) {
  192. +         if (str2 != NULL) {
  193. +             bias += extra_len(str2, (char *) NULL);
  194. +             str2 = NULL;
  195. +         }
  196. +         }
  197. +         else ++bias;    /* don't forget the star */
  198. +         p = q + 1;
  199. +     }
  200. +     while (p[-1] != '\0');
  201. +     return bias + p - str1;
  202. + }
  203. + 
  204. + /*
  205. +  *    Add the specifiers (and double stars) for the given strings (user
  206. +  *    string, plus default string) to the destination string.
  207. +  */
  208. + 
  209.   static    void
  210. + add_subdir_paths(dst, dst_first, src, src_default)
  211. +     char *dst, *dst_first, *src, *src_default;
  212. + {
  213. +     char    *q;
  214. + 
  215. +     do {
  216. +         q = index(src, PATH_SEP);
  217. +         if (q == NULL) q = src + strlen(src);
  218. +         if (q == src) {
  219. +         if (src_default != NULL) {
  220. +             add_subdir_paths(dst, dst_first, src_default, (char *)NULL);
  221. +             dst += strlen(dst);
  222. +             src_default = NULL;
  223. +         }
  224. +         }
  225. +         else {
  226. +         if (dst != dst_first) *dst++ = PATH_SEP;
  227. +         bcopy(src, dst, q - src);
  228. +         dst += q - src;
  229. +         *dst++ = '*';
  230. +         }
  231. +         src = q + 1;
  232. +     }
  233. +     while (src[-1] != '\0');
  234. +     *dst = '\0';
  235. + }
  236. + 
  237. + /*
  238. +  *    Make a subdirectory entry.
  239. +  */
  240. + 
  241. + static    struct subdir_entry *
  242. + make_subdir_entry(index, name)
  243. +     char *index, *name;
  244. + {
  245. +     struct subdir_entry *new_entry;
  246. +     static    struct subdir_entry    **subdir_tail = &subdir_head;
  247. + 
  248. +     *subdir_tail = new_entry = (struct subdir_entry *)
  249. +         xmalloc(sizeof(struct subdir_entry), "subdirectory list entry");
  250. +     subdir_tail = &(new_entry->next);
  251. +     new_entry->name = strcpy(xmalloc(strlen(name) + 1,
  252. +         "subdirectory entry string"), name);
  253. +     new_entry->index = index;
  254. +     new_entry->next = NULL;
  255. +     return new_entry;
  256. + }
  257. + 
  258. + /*
  259. +  *    Create the subdirectory linked list for the given initial string
  260. +  */
  261. + 
  262. + static    void
  263. + add_subdirs(str, len, recurs)
  264. +     char *str;
  265. +     int len;
  266. +     Boolean recurs;
  267. + {
  268. +     int    len1 = len;
  269. +     char    temp[FILENAMESIZE];
  270. +     struct subdir_entry *next_subdir;
  271. +     DIR    *dir;
  272. +     directory_entry_type    e;
  273. + 
  274. +     bcopy(str, temp, len);
  275. +     if (len > 0 && temp[len - 1] != '/') temp[len1++] = '/';
  276. +     temp[len1] = '\0';
  277. +     next_subdir = make_subdir_entry(str, temp + len);
  278. +     do {
  279. +         /* By changing directories, we save a bunch of string
  280. +            concatenations (and make the pathnames the kernel looks up
  281. +            shorter).  */
  282. +         Strcpy(temp + len, next_subdir->name);
  283. +         if (chdir (temp) != 0) continue;
  284. + 
  285. +         dir = opendir (".");
  286. +         if (dir == NULL) continue;
  287. + 
  288. +         len1 = strlen(temp);
  289. +         if (len1 == 0 || temp[len1 - 1] != '/') temp[len1++] = '/';
  290. +         while ((e = readdir (dir)) != NULL)
  291. +           {
  292. +         if (is_dir (e->d_name) && strcmp (e->d_name, ".") != 0
  293. +             && strcmp (e->d_name, "..") != 0)
  294. +           {
  295. +             Strcpy(temp + len1, e->d_name);
  296. +             (void) make_subdir_entry(str, temp + len);
  297. +           }
  298. +           }
  299. +         (void) closedir (dir);
  300. + 
  301. + 
  302. +         /* Change back to the current directory, in case the path
  303. +            contains relative directory names.  */
  304. +         if (chdir (cwd) != 0) {
  305. +         perror (cwd);
  306. +         exit (errno);
  307. +         }
  308. +     }
  309. +     while (recurs && (next_subdir = next_subdir->next) != NULL);
  310. + }
  311. + 
  312. + /*
  313. +  *    Recursively figure out the subdirectory tree and precompute the
  314. +  *    list of subdirectories to search.
  315. +  */
  316. + 
  317. + static    void
  318. + compute_subdir_paths(fp, fp_default)
  319. +     char *fp, *fp_default;
  320. + {
  321. +     char    *star_loc = NULL;
  322. +     char    *endp;
  323. + 
  324. +     do {
  325. +         if (star_loc == NULL) {
  326. +         star_loc = index(fp, '*');
  327. +         if (star_loc == NULL) star_loc = fp + strlen(fp);
  328. +         }
  329. +         endp = index(fp, PATH_SEP);
  330. +         if (endp == NULL) endp = fp + strlen(fp);
  331. +         if (endp == fp) {
  332. +         if (fp_default != NULL) {
  333. +             compute_subdir_paths(fp_default, (char *) NULL);
  334. +             fp_default = NULL;
  335. +         }
  336. +         }
  337. +         else if (star_loc < endp) {
  338. +         add_subdirs(fp, star_loc - fp, star_loc[1] == '*');
  339. +         star_loc = NULL;
  340. +         }
  341. +         fp = endp + 1;
  342. +     }
  343. +     while (fp[-1] != '\0');
  344. + }
  345. + #endif    /* SEARCH_SUBDIRECTORIES */
  346. + 
  347. + static    void
  348.   get_sizes(size_list, spp)
  349.       char    *size_list;
  350.       int    **spp;
  351. ***************
  352. *** 79,90 ****
  353.       int    *sp, *sp1, *sp2;
  354.       unsigned int n;
  355.       char    *p;
  356.   
  357. !     if ((font_path = getenv("XDVIFONTS")) == NULL) {
  358.           font_path = default_font_path;
  359.           default_font_path = NULL;
  360.       }
  361.   
  362.       size_list = getenv("XDVISIZES");
  363.       n = 1;    /* count number of sizes */
  364.       if (size_list == NULL || *size_list == PATH_SEP)
  365. --- 320,360 ----
  366.       int    *sp, *sp1, *sp2;
  367.       unsigned int n;
  368.       char    *p;
  369. + #ifdef    SEARCH_SUBDIRECTORIES
  370. +     char    *q;
  371. + #endif
  372.   
  373. !     if ((font_path = getenv("XDVIFONTS")) == NULL
  374. !         && (font_path = getenv("TEXFONTS")) == NULL) {
  375.           font_path = default_font_path;
  376.           default_font_path = NULL;
  377.       }
  378.   
  379. + #ifdef    SEARCH_SUBDIRECTORIES
  380. +     p = getenv ("TEXFONTS_SUBDIR");
  381. +     if (p == NULL) p = "";
  382. +     q = xmalloc((unsigned) strlen(font_path)
  383. +         + extra_len(p, default_subdir_path) + 1,
  384. +         "initializing font searching");
  385. +     Strcpy(q, font_path);
  386. +     add_subdir_paths(q + strlen(q), q, p, default_subdir_path);
  387. +     font_path = q;
  388. + 
  389. +     /* Unfortunately, we can't look in the environment for the current
  390. +        directory, because if we are running under a program (let's say
  391. +        Emacs), the PWD variable might have been set by Emacs' parent
  392. +        to the current directory at the time Emacs was invoked.  This
  393. +        is not necessarily the same directory the user expects to be
  394. +        in.  So, we must always call getcwd(3) or getwd(3), even though
  395. +        they are slow and prone to hang in networked installations.  */
  396. +     cwd = getcwd ((char *) NULL, FILENAMESIZE + 2);
  397. +     if (cwd == NULL) {
  398. +         perror ("getcwd");
  399. +         exit (errno);
  400. +     }
  401. +     compute_subdir_paths(font_path, default_font_path);
  402. + #endif
  403. + 
  404.       size_list = getenv("XDVISIZES");
  405.       n = 1;    /* count number of sizes */
  406.       if (size_list == NULL || *size_list == PATH_SEP)
  407. ***************
  408. *** 92,98 ****
  409.           ++n;
  410.       if (size_list != NULL)
  411.           for (p = size_list; (p = index(p, PATH_SEP)) != NULL; ++p) ++n;
  412. !     sizes = (int *) malloc(n * sizeof(int));
  413.       sizend = sizes + n;
  414.       sp = sizes;    /* get the actual sizes */
  415.       if (size_list == NULL || *size_list == PATH_SEP)
  416. --- 362,368 ----
  417.           ++n;
  418.       if (size_list != NULL)
  419.           for (p = size_list; (p = index(p, PATH_SEP)) != NULL; ++p) ++n;
  420. !     sizes = (int *) xmalloc(n * sizeof(int), "size list");
  421.       sizend = sizes + n;
  422.       sp = sizes;    /* get the actual sizes */
  423.       if (size_list == NULL || *size_list == PATH_SEP)
  424. ***************
  425. *** 122,128 ****
  426.       int    count;
  427.   {
  428.       char    *p = path,
  429. !         nm[128],
  430.           *n = nm,
  431.           c;
  432.       Boolean    f_used = False;
  433. --- 392,398 ----
  434.       int    count;
  435.   {
  436.       char    *p = path,
  437. !         nm[FILENAMESIZE],
  438.           *n = nm,
  439.           c;
  440.       Boolean    f_used = False;
  441. ***************
  442. *** 129,134 ****
  443. --- 399,418 ----
  444.       Boolean    p_used = False;
  445.       FILE    *f;
  446.   
  447. + #ifdef    SEARCH_SUBDIRECTORIES
  448. +     if (next_subdir != NULL && next_subdir->index == p) {
  449. +         int len = index(p, '*') - p;
  450. + 
  451. +         bcopy(p, n, len);
  452. +         p += len;
  453. +         n += len;
  454. +         Strcpy(n, next_subdir->name);
  455. +         n += strlen(n);
  456. +         ++p;
  457. +         if (*p == '*') ++p;
  458. +         if (*p != '/') *n++ = '/';
  459. +     }
  460. + #endif
  461.       for (;;) {
  462.           c = *p++;
  463.           if (c==PATH_SEP || c=='\0') {
  464. ***************
  465. *** 168,174 ****
  466.           f = fopen(nm, OPEN_MODE);
  467.       }
  468.       if (f != NULL) {
  469. !         *name = malloc((unsigned) (n - nm + 1));
  470.           Strcpy(*name, nm);
  471.       }
  472.       return f;
  473. --- 452,458 ----
  474.           f = fopen(nm, OPEN_MODE);
  475.       }
  476.       if (f != NULL) {
  477. !         *name = xmalloc((unsigned) (n - nm + 1), "font file name");
  478.           Strcpy(*name, nm);
  479.       }
  480.       return f;
  481. ***************
  482. *** 185,191 ****
  483.       char    **name;
  484.       char    *font_path, *default_font_path;
  485.   {
  486. !     char    *p;
  487.       FILE    *f;
  488.       int    pkmag    = (pxlmag + 2) / 5;
  489.   
  490. --- 469,475 ----
  491.       char    **name;
  492.       char    *font_path, *default_font_path;
  493.   {
  494. !     char    *p    = font_path;
  495.       FILE    *f;
  496.       int    pkmag    = (pxlmag + 2) / 5;
  497.   
  498. ***************
  499. *** 192,201 ****
  500.       /*
  501.        * loop over paths
  502.        */
  503. !     for (p = font_path;; ++p) {
  504.           int count = 0;
  505.   
  506. !         if (*p == ':' || *p == '\0') {
  507.           if (default_font_path != NULL &&
  508.               (f = try_size(font, pxlmag, name, default_font_path,
  509.               (char *) NULL)) != NULL)
  510. --- 476,488 ----
  511.       /*
  512.        * loop over paths
  513.        */
  514. ! #ifdef    SEARCH_SUBDIRECTORIES
  515. !     next_subdir = subdir_head;
  516. ! #endif
  517. !     for (;;) {
  518.           int count = 0;
  519.   
  520. !         if (*p == PATH_SEP || *p == '\0') {
  521.           if (default_font_path != NULL &&
  522.               (f = try_size(font, pxlmag, name, default_font_path,
  523.               (char *) NULL)) != NULL)
  524. ***************
  525. *** 215,222 ****
  526. --- 502,516 ----
  527.           (f = formatted_open(p, font, "pxl", pxlmag, name, count++))
  528.               != NULL)
  529.               return f;
  530. + #ifdef    SEARCH_SUBDIRECTORIES
  531. +         if (next_subdir != NULL && next_subdir->index == p) {
  532. +         next_subdir = next_subdir->next;
  533. +         if (next_subdir != NULL && next_subdir->index == p) continue;
  534. +         }
  535. + #endif
  536.           p = index(p, PATH_SEP);
  537.           if (p == NULL) break;
  538. +         ++p;
  539.       }
  540.       return NULL;
  541.   }
  542. ***************
  543. *** 234,251 ****
  544.   {
  545.       FILE    *f;
  546.       int    *p1, *p2, pxlmag;
  547.   
  548.       /*
  549.        * Loop over sizes.  Try actual size first, then closest sizes.
  550.        */
  551.       pxlmag = mag + 0.5;
  552. !     if ((f = try_size(font, *mag_ret = pxlmag, name, font_path,
  553.           default_font_path)) != NULL)
  554.           return f;
  555.       if (pxlmag < mag) ++pxlmag; else --pxlmag;
  556. !     if ((f = try_size(font, *mag_ret = pxlmag, name, font_path,
  557.           default_font_path)) != NULL)
  558.           return f;
  559.       for (p2 = sizes; p2 < sizend; ++p2) if (*p2 >= mag) break;
  560.       p1 = p2;
  561.       for (;;) {
  562. --- 528,562 ----
  563.   {
  564.       FILE    *f;
  565.       int    *p1, *p2, pxlmag;
  566. +     char    *path_to_use = font_path;
  567.   
  568.       /*
  569.        * Loop over sizes.  Try actual size first, then closest sizes.
  570. +        If the pathname is absolutely or explicitly relative, don't
  571. +        use the usual paths to search for it; just look for it in the
  572. +        directory specified.
  573.        */
  574.       pxlmag = mag + 0.5;
  575. ! 
  576. ! #ifndef    VMS
  577. !     if (*font == '/') path_to_use = "/";
  578. !     else if (*font == '.' && (*(font + 1) == '/'
  579. !         || (*(font + 1) == '.' && *(font + 2) == '/')))
  580. !         path_to_use = ".";
  581. ! #endif
  582. ! 
  583. !     if ((f = try_size(font, *mag_ret = pxlmag, name, path_to_use,
  584.           default_font_path)) != NULL)
  585.           return f;
  586. + 
  587. +     /* Try at one away from the size we just tried, to account
  588. +        for rounding error.  */
  589.       if (pxlmag < mag) ++pxlmag; else --pxlmag;
  590. !     if ((f = try_size(font, *mag_ret = pxlmag, name, path_to_use,
  591.           default_font_path)) != NULL)
  592.           return f;
  593. + 
  594. +     /* Now try at all the sizes. */
  595.       for (p2 = sizes; p2 < sizend; ++p2) if (*p2 >= mag) break;
  596.       p1 = p2;
  597.       for (;;) {
  598. ***************
  599. *** 256,262 ****
  600.           else if (p2 >= sizend || mag * mag <= p1[-1] * *p2)
  601.               pxlmag = *--p1;
  602.           else pxlmag = *p2++;
  603. !         if ((f = try_size(font, *mag_ret = pxlmag, name, font_path,
  604.               default_font_path)) != NULL)
  605.           return f;
  606.       }
  607. --- 567,573 ----
  608.           else if (p2 >= sizend || mag * mag <= p1[-1] * *p2)
  609.               pxlmag = *--p1;
  610.           else pxlmag = *p2++;
  611. !         if ((f = try_size(font, *mag_ret = pxlmag, name, path_to_use,
  612.               default_font_path)) != NULL)
  613.           return f;
  614.       }
  615. ***************
  616. *** 263,273 ****
  617.   }
  618.   
  619.   FILE *
  620. ! pxl_open(font, font_ret, mag, mag_ret, factor, name)
  621.       char    *font, **font_ret;
  622.       float    mag;
  623.       int    *mag_ret;
  624. -     float    *factor;
  625.       char    **name;
  626.   {
  627.       FILE    *f;
  628. --- 574,583 ----
  629.   }
  630.   
  631.   FILE *
  632. ! pxl_open(font, font_ret, mag, mag_ret, name)
  633.       char    *font, **font_ret;
  634.       float    mag;
  635.       int    *mag_ret;
  636.       char    **name;
  637.   {
  638.       FILE    *f;
  639. ***************
  640. *** 274,280 ****
  641.       int    actual_pt, low_pt, high_pt, trial_pt;
  642.       char    fn[50], *fnend;
  643.   
  644. -     *factor = 1.0;
  645.       f = pre_pxl_open(font, mag, mag_ret, name);
  646.       if (f != NULL) {
  647.           *font_ret = NULL;
  648. --- 584,589 ----
  649. ***************
  650. *** 297,304 ****
  651.           Sprintf(fnend, "%d", trial_pt);
  652.           f = pre_pxl_open(fn, mag * actual_pt / trial_pt, mag_ret, name);
  653.           if (f != NULL) {
  654. !             *font_ret = strcpy(malloc((unsigned) strlen(fn) + 1), fn);
  655. !             *factor = (float) actual_pt / trial_pt;
  656.               return f;
  657.           }
  658.           }
  659. --- 606,613 ----
  660.           Sprintf(fnend, "%d", trial_pt);
  661.           f = pre_pxl_open(fn, mag * actual_pt / trial_pt, mag_ret, name);
  662.           if (f != NULL) {
  663. !             *font_ret = strcpy(xmalloc((unsigned) strlen(fn) + 1,
  664. !             "name of font used"), fn);
  665.               return f;
  666.           }
  667.           }
  668. ***************
  669. *** 307,313 ****
  670.           *font_ret = alt_font;
  671.           f = pre_pxl_open(alt_font, mag, mag_ret, name);
  672.           if (f != NULL)
  673. !         *font_ret = strcpy(malloc((unsigned) strlen(alt_font) + 1),
  674.               alt_font);
  675.       }
  676.       return f;
  677. --- 616,623 ----
  678.           *font_ret = alt_font;
  679.           f = pre_pxl_open(alt_font, mag, mag_ret, name);
  680.           if (f != NULL)
  681. !         *font_ret = strcpy(xmalloc((unsigned) strlen(alt_font) + 1,
  682. !             "name of font used"),
  683.               alt_font);
  684.       }
  685.       return f;
  686. diff -cr old/tpic.c new/tpic.c
  687. *** old/tpic.c    Sun Oct 21 14:47:54 1990
  688. --- new/tpic.c    Fri Dec  7 16:54:30 1990
  689. ***************
  690. *** 410,415 ****
  691.       else if (strcmp(command, "sh") == 0) shade_last();
  692.       else if (strcmp(command, "wh") == 0) whiten_last();
  693.       else if (strcmp(command, "bk") == 0) blacken_last();
  694. !     else if (spec_warn_now)
  695.       Fprintf(stderr, "%s:  special \"%s\" not implemented\n", prog, orig_cp);
  696.   }
  697. --- 410,415 ----
  698.       else if (strcmp(command, "sh") == 0) shade_last();
  699.       else if (strcmp(command, "wh") == 0) whiten_last();
  700.       else if (strcmp(command, "bk") == 0) blacken_last();
  701. !     else if (!hush_spec_now)
  702.       Fprintf(stderr, "%s:  special \"%s\" not implemented\n", prog, orig_cp);
  703.   }
  704. diff -cr old/xdvi.c new/xdvi.c
  705. *** old/xdvi.c    Sun Oct 21 14:49:08 1990
  706. --- new/xdvi.c    Mon Feb  4 13:05:55 1991
  707. ***************
  708. *** 116,121 ****
  709. --- 116,145 ----
  710.   #define    DPY    DISP,
  711.   static    Screen    *SCRN;
  712.   static    Cursor    redraw_cursor, ready_cursor;
  713. + 
  714. + #ifdef    VMS
  715. + /*
  716. +  * Magnifying glass cursor
  717. +  *
  718. +  * Developed by Tom Sawyer, April 1990
  719. +  * Contibuted by Hunter Goatley, January 1991
  720. +  *
  721. +  */
  722. + 
  723. + #define mag_glass_width 16
  724. + #define mag_glass_height 16
  725. + #define mag_glass_x_hot 6
  726. + #define mag_glass_y_hot 6
  727. + static char mag_glass_bits[] = {
  728. +     0xf8, 0x03, 0x0c, 0x06, 0xe2, 0x09, 0x13, 0x1a, 0x01, 0x14, 0x01, 0x14,
  729. +     0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x03, 0x10, 0x02, 0x18, 0x0c, 0x34,
  730. +     0xf8, 0x6f, 0x00, 0xd8, 0x00, 0xb0, 0x00, 0xe0
  731. + };
  732. + #include <decw$cursor.h>    /* Include the DECWindows cursor symbols */
  733. + static    int    DECWCursorFont;    /* Space for the DECWindows cursor font  */
  734. + static    Pixmap    MagnifyPixmap;    /* Pixmap to hold our special mag-glass  */
  735. + #endif    /* VMS */
  736. + 
  737.   #define    SetCursor(x)    XDefineCursor(DISP, WINDOW(mane), x)
  738.   #define    ClearPage(wr)    XClearWindow(DISP, WINDOW(wr));
  739.   #define    ClearArea(win, x, y, w, h)    XClearArea(DISP, win, x, y, w, h, False)
  740. ***************
  741. *** 160,166 ****
  742.   int    offset_x, offset_y;
  743.   int    unshrunk_paper_w, unshrunk_paper_h;
  744.   int    unshrunk_page_w, unshrunk_page_h;
  745. ! Boolean    spec_warn    = True;
  746.   static    char    *paper        = DEFAULT_PAPER;
  747.   static    char    *sidemargin, *topmargin;
  748.   static    char    *xoffset, *yoffset;
  749. --- 184,191 ----
  750.   int    offset_x, offset_y;
  751.   int    unshrunk_paper_w, unshrunk_paper_h;
  752.   int    unshrunk_page_w, unshrunk_page_h;
  753. ! Boolean    hush_spec    = False;
  754. ! Boolean    hush_chars    = False;
  755.   static    char    *paper        = DEFAULT_PAPER;
  756.   static    char    *sidemargin, *topmargin;
  757.   static    char    *xoffset, *yoffset;
  758. ***************
  759. *** 309,320 ****
  760.           {"Shrink2",    "sh2",        2 << 8 | 's',    200},
  761.           {"Shrink3",    "sh3",        3 << 8 | 's',    250},
  762.           {"Shrink4",    "sh4",        4 << 8 | 's',    300},
  763. !         {"Next",    "next",        'n',        400},
  764. !         {"Page+5",    "next5",    5 << 8 | 'n',    450},
  765. !         {"Page+10",    "next10",    10 << 8 | 'n',    500},
  766. !         {"Prev",    "prev",        'p',        600},
  767. !         {"Page-5",    "prev5",    5 << 8 | 'p',    650},
  768. !         {"Page-10",    "prev10",    10 << 8 | 'p',    700},
  769.   };
  770.   
  771.   static    void    handle_command();
  772. --- 334,345 ----
  773.           {"Shrink2",    "sh2",        2 << 8 | 's',    200},
  774.           {"Shrink3",    "sh3",        3 << 8 | 's',    250},
  775.           {"Shrink4",    "sh4",        4 << 8 | 's',    300},
  776. !         {"Page-10",    "prev10",    10 << 8 | 'p',    400},
  777. !         {"Page-5",    "prev5",    5 << 8 | 'p',    450},
  778. !         {"Prev",    "prev",        'p',        500},
  779. !         {"Next",    "next",        'n',        600},
  780. !         {"Page+5",    "next5",    5 << 8 | 'n',    650},
  781. !         {"Page+10",    "next10",    10 << 8 | 'n',    700},
  782.   };
  783.   
  784.   static    void    handle_command();
  785. ***************
  786. *** 415,421 ****
  787.   char    *sprintf();
  788.   #endif
  789.   
  790. - char    *malloc();
  791.   double    atof();
  792.   void    exit();
  793.   
  794. --- 440,445 ----
  795. ***************
  796. *** 1192,1197 ****
  797. --- 1216,1224 ----
  798.           case 'q':
  799.           case '\003':    /* control-C */
  800.           case '\004':    /* control-D */
  801. + #ifdef    VMS
  802. +         case '\032':    /* control-Z */
  803. + #endif
  804.           exit(0);
  805.           case 'n':
  806.           case 'f':
  807. ***************
  808. *** 1362,1368 ****
  809.       if (0 <= next_page && next_page < total_pages) {
  810.           if (current_page != next_page) {
  811.           current_page = next_page;
  812. !         spec_warn_now = spec_warn;
  813.           if (!keep_flag) home(False);
  814.           }
  815.           canit = True;
  816. --- 1389,1395 ----
  817.       if (0 <= next_page && next_page < total_pages) {
  818.           if (current_page != next_page) {
  819.           current_page = next_page;
  820. !         hush_spec_now = hush_spec;
  821.           if (!keep_flag) home(False);
  822.           }
  823.           canit = True;
  824. ***************
  825. *** 1629,1635 ****
  826.       }
  827.       else {
  828.           draw_page();
  829. !         spec_warn_now = False;
  830.       }
  831.   }
  832.   
  833. --- 1656,1662 ----
  834.       }
  835.       else {
  836.           draw_page();
  837. !         hush_spec_now = True;
  838.       }
  839.   }
  840.   
  841. ***************
  842. *** 1746,1756 ****
  843.   #ifndef    VMS
  844.   #ifdef    BUTTONS
  845.       Fputs("\
  846. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-S <density>] [-p <pixels>] [-l] [-sw]\n\
  847.       [-expert] [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  848. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>] [-rv]\
  849. ! \n\
  850. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>]\n\
  851.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  852.   [-cr <color>]\n\
  853.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  854. --- 1773,1783 ----
  855.   #ifndef    VMS
  856.   #ifdef    BUTTONS
  857.       Fputs("\
  858. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-S <density>] [-p <pixels>] [-l] [-rv]\n\
  859.       [-expert] [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  860. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  861. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  862. !     [-hushspecials] [-hushchars] [-hush]\n\
  863.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  864.   [-cr <color>]\n\
  865.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  866. ***************
  867. *** 1758,1768 ****
  868.       stderr);
  869.   #else    /* !BUTTONS */
  870.       Fputs("\
  871. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-S <density>] [-p <pixels>] [-l] [-sw]\n\
  872.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  873. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>] [-rv]\
  874. ! \n\
  875. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>]\n\
  876.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  877.   [-cr <color>]\n\
  878.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  879. --- 1785,1795 ----
  880.       stderr);
  881.   #else    /* !BUTTONS */
  882.       Fputs("\
  883. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-S <density>] [-p <pixels>] [-l] [-rv]\n\
  884.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  885. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  886. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  887. !     [-hushspecials] [-hushchars] [-hush]\n\
  888.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  889.   [-cr <color>]\n\
  890.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  891. ***************
  892. *** 1771,1795 ****
  893.   #endif    /* BUTTONS */
  894.   #else    /* VMS */
  895.       Fputs("\
  896. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-density <%>] [-p <pixels>] [-l] [-sw]\n\
  897.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  898. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>] [-rv]\
  899.   \n", stderr);
  900.       Fputs("\
  901. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>]\n\
  902.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  903.   [-cr <color>]\n\
  904.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  905. !     [-iconic] [-display <host:display>] [-copy] [-thorough] dvi_file\n",
  906.       stderr);
  907.   #endif    /* VMS */
  908.   #else    /* X10 */
  909.       Fputs("\
  910. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-S <density>] [-p <pixels>] [-l] [-sw]\n\
  911.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  912. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>] [-rv]\
  913. ! \n\
  914. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>]\n\
  915.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  916.   [-cr <color>]\n\
  917.       [-bw <width>] [-geometry <geometry> | =<geometry>]\n\
  918. --- 1798,1823 ----
  919.   #endif    /* BUTTONS */
  920.   #else    /* VMS */
  921.       Fputs("\
  922. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-density <%>] [-p <pixels>] [-l] [-rv]\n\
  923.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  924. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\
  925.   \n", stderr);
  926.       Fputs("\
  927. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  928. !     [-hushspecials] [-hushchars] [-hush]\n\
  929.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  930.   [-cr <color>]\n\
  931.       [-bw <width>] [-geometry <geometry>] [-icongeometry <geometry>]\n\
  932. !     [-iconic] [-display <host::display>] [-copy] [-thorough] dvi_file\n",
  933.       stderr);
  934.   #endif    /* VMS */
  935.   #else    /* X10 */
  936.       Fputs("\
  937. ! Usage: xdvi [+[<page>]] [-s <shrink>] [-S <density>] [-p <pixels>] [-l]\n\
  938.       [-paper <papertype>] [-mgs[n] <size>] [-altfont <font>]\n\
  939. !     [-margins <dimen>] [-sidemargin <dimen>] [-topmargin <dimen>]\n\
  940. !     [-offsets <dimen>] [-xoffset <dimen>] [-yoffset <dimen>] [-keep]\n\
  941. !     [-hushspecials] [-hushchars] [-hush]\n\
  942.       [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] \
  943.   [-cr <color>]\n\
  944.       [-bw <width>] [-geometry <geometry> | =<geometry>]\n\
  945. ***************
  946. *** 1838,1845 ****
  947.   {"-altfont",    ".altFont",    XrmoptionSepArg,    (caddr_t) NULL},
  948.   {"-l",        ".listFonts",    XrmoptionNoArg,        (caddr_t) "on"},
  949.   {"+l",        ".listFonts",    XrmoptionNoArg,        (caddr_t) "off"},
  950. ! {"-sw",        ".specialWarn",    XrmoptionNoArg,        (caddr_t) "on"},
  951. ! {"+sw",        ".specialWarn",    XrmoptionNoArg,        (caddr_t) "off"},
  952.   {"-fg",        ".foreground",    XrmoptionSepArg,    (caddr_t) NULL},
  953.   {"-foreground",    ".foreground",    XrmoptionSepArg,    (caddr_t) NULL},
  954.   {"-bg",        ".background",    XrmoptionSepArg,    (caddr_t) NULL},
  955. --- 1866,1877 ----
  956.   {"-altfont",    ".altFont",    XrmoptionSepArg,    (caddr_t) NULL},
  957.   {"-l",        ".listFonts",    XrmoptionNoArg,        (caddr_t) "on"},
  958.   {"+l",        ".listFonts",    XrmoptionNoArg,        (caddr_t) "off"},
  959. ! {"-hushspecials", ".hushSpecials", XrmoptionNoArg,    (caddr_t) "on"},
  960. ! {"+hushspecials", ".hushSpecials", XrmoptionNoArg,    (caddr_t) "off"},
  961. ! {"-hushchars",    ".hushLostChars", XrmoptionNoArg,    (caddr_t) "on"},
  962. ! {"+hushchars",    ".hushLostChars", XrmoptionNoArg,    (caddr_t) "off"},
  963. ! {"-hush",    ".Hush",    XrmoptionNoArg,        (caddr_t) "on"},
  964. ! {"+hush",    ".Hush",    XrmoptionNoArg,        (caddr_t) "off"},
  965.   {"-fg",        ".foreground",    XrmoptionSepArg,    (caddr_t) NULL},
  966.   {"-foreground",    ".foreground",    XrmoptionSepArg,    (caddr_t) NULL},
  967.   {"-bg",        ".background",    XrmoptionSepArg,    (caddr_t) NULL},
  968. ***************
  969. *** 1847,1852 ****
  970. --- 1879,1886 ----
  971.   {"-hl",        ".highlight",    XrmoptionSepArg,    (caddr_t) NULL},
  972.   {"-cr",        ".cursorColor",    XrmoptionSepArg,    (caddr_t) NULL},
  973.   {"-icongeometry",".iconGeometry",XrmoptionSepArg,    (caddr_t) NULL},
  974. + {"-keep",    ".keepPosition",XrmoptionNoArg,        (caddr_t) "on"},
  975. + {"+keep",    ".keepPosition",XrmoptionNoArg,        (caddr_t) "off"},
  976.   {"-copy",    ".copy",    XrmoptionNoArg,        (caddr_t) "on"},
  977.   {"+copy",    ".copy",    XrmoptionNoArg,        (caddr_t) "off"},
  978.   {"-thorough",    ".thorough",    XrmoptionNoArg,        (caddr_t) "on"},
  979. ***************
  980. *** 1888,1895 ****
  981.     (Cardinal) &list_fonts, XtRBoolean, (caddr_t) &list_fonts},
  982.   {"reverseVideo", "ReverseVideo", XtRBoolean, sizeof(Boolean),
  983.     (Cardinal) &reverse, XtRBoolean, (caddr_t) &reverse},
  984. ! {"specialWarn", "SpecialWarn", XtRBoolean, sizeof(Boolean),
  985. !   (Cardinal) &spec_warn, XtRBoolean, (caddr_t) &spec_warn},
  986.   {"foreground", "Foreground", XtRPixel, sizeof(Pixel),
  987.     (Cardinal)&fore_Pixel, XtRPixel, (caddr_t) &fore_Pixel},
  988.   {"foreground", "Foreground", XtRString, sizeof(char *),
  989. --- 1922,1931 ----
  990.     (Cardinal) &list_fonts, XtRBoolean, (caddr_t) &list_fonts},
  991.   {"reverseVideo", "ReverseVideo", XtRBoolean, sizeof(Boolean),
  992.     (Cardinal) &reverse, XtRBoolean, (caddr_t) &reverse},
  993. ! {"hushSpecials", "Hush", XtRBoolean, sizeof(Boolean),
  994. !   (Cardinal) &hush_spec, XtRBoolean, (caddr_t) &hush_spec},
  995. ! {"hushLostChars", "Hush", XtRBoolean, sizeof(Boolean),
  996. !   (Cardinal) &hush_chars, XtRBoolean, (caddr_t) &hush_chars},
  997.   {"foreground", "Foreground", XtRPixel, sizeof(Pixel),
  998.     (Cardinal)&fore_Pixel, XtRPixel, (caddr_t) &fore_Pixel},
  999.   {"foreground", "Foreground", XtRString, sizeof(char *),
  1000. ***************
  1001. *** 1912,1917 ****
  1002. --- 1948,1955 ----
  1003.     (Cardinal)&curs_color, XtRString, NULL},
  1004.   {"iconGeometry", "IconGeometry", XtRString, sizeof(char *),
  1005.     (Cardinal)&icon_geometry, XtRString, NULL},
  1006. + {"keepPosition", "KeepPosition", XtRBoolean, sizeof(Boolean),
  1007. +   (Cardinal)&keep_flag, XtRBoolean, (caddr_t) &keep_flag},
  1008.   {"copy", "Copy", XtRBoolean, sizeof(Boolean),
  1009.     (Cardinal)©, XtRBoolean, (caddr_t) ©},
  1010.   {"thorough", "Thorough", XtRBoolean, sizeof(Boolean),
  1011. ***************
  1012. *** 1953,1958 ****
  1013. --- 1991,1997 ----
  1014.   static    char    *geometry;
  1015.   static    char    *margins;
  1016.   static    char    *offsets;
  1017. + static    Boolean    hush;
  1018.   
  1019.   #ifndef X10
  1020.   static    Boolean    iconic    = False;
  1021. ***************
  1022. *** 2012,2019 ****
  1023.   {"+l",        "listFonts",    FalseArg, BooleanArg, 1,(caddr_t) &list_fonts},
  1024.   {"-rv",        NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &reverse},
  1025.   {"+rv",        "reverseVideo",    FalseArg, BooleanArg, 1,(caddr_t) &reverse},
  1026. ! {"-sw",        NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &spec_warn},
  1027. ! {"+sw",        "specialWarn",    FalseArg, BooleanArg, 1,(caddr_t) &spec_warn},
  1028.   {"-bw",        NULL,        SepArg,    NumberArg, 2,    (caddr_t) &bwidth},
  1029.   {"-borderwidth", "borderWidth",    SepArg,    NumberArg, 1,    (caddr_t) &bwidth},
  1030.   {"-fg",        NULL,        SepArg,    StringArg, 2,    (caddr_t) &fore_color},
  1031. --- 2051,2062 ----
  1032.   {"+l",        "listFonts",    FalseArg, BooleanArg, 1,(caddr_t) &list_fonts},
  1033.   {"-rv",        NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &reverse},
  1034.   {"+rv",        "reverseVideo",    FalseArg, BooleanArg, 1,(caddr_t) &reverse},
  1035. ! {"-hush",    NULL,        TrueArg, BooleanArg, 6,    (caddr_t) &hush},
  1036. ! {"+hush",    "Hush",        FalseArg, BooleanArg, 5,(caddr_t) &hush},
  1037. ! {"-hushspecials", NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &hush_spec},
  1038. ! {"+hushspecials", "hushSpecials", FalseArg, BooleanArg, 1,(caddr_t) &hush_spec},
  1039. ! {"-hushchars",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &hush_chars},
  1040. ! {"+hushchars",    "hushLostChars", FalseArg, BooleanArg, 1,(caddr_t) &hush_chars},
  1041.   {"-bw",        NULL,        SepArg,    NumberArg, 2,    (caddr_t) &bwidth},
  1042.   {"-borderwidth", "borderWidth",    SepArg,    NumberArg, 1,    (caddr_t) &bwidth},
  1043.   {"-fg",        NULL,        SepArg,    StringArg, 2,    (caddr_t) &fore_color},
  1044. ***************
  1045. *** 2032,2037 ****
  1046. --- 2075,2082 ----
  1047.   {"-icongeometry","iconGeometry",StickyArg, StringArg, 1,(caddr_t) &icon_geometry},
  1048.   {"-iconic",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &iconic},
  1049.   {"+iconic",    "iconic",    FalseArg, BooleanArg, 1,(caddr_t) &iconic},
  1050. + {"-keep",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &keep_flag},
  1051. + {"+keep",    "keepPosition",    FalseArg, BooleanArg, 1,(caddr_t) &keep_flag},
  1052.   {"-copy",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) ©},
  1053.   {"+copy",    "copy",        FalseArg, BooleanArg, 1,(caddr_t) ©},
  1054.   {"-thorough",    NULL,        TrueArg, BooleanArg, 2,    (caddr_t) &thorough},
  1055. ***************
  1056. *** 2061,2069 ****
  1057.       char    **argvend = argv + argc;
  1058.       char    *optstring;
  1059.       caddr_t    addr;
  1060. !     struct option *opt, *candidate;
  1061. !     int    len1, len2, matchlen, i;
  1062.   
  1063.       for (arg = argv + 1; arg < argvend; ++arg) {
  1064.           len1 = strlen(*arg);
  1065.           candidate = NULL;
  1066. --- 2106,2117 ----
  1067.       char    **argvend = argv + argc;
  1068.       char    *optstring;
  1069.       caddr_t    addr;
  1070. !     struct option *opt, *lastopt, *candidate;
  1071. !     int    len1, len2, matchlen;
  1072.   
  1073. +     /*
  1074. +      * Step 1.  Process command line options.
  1075. +      */
  1076.       for (arg = argv + 1; arg < argvend; ++arg) {
  1077.           len1 = strlen(*arg);
  1078.           candidate = NULL;
  1079. ***************
  1080. *** 2120,2128 ****
  1081.           case StringArg:    *((char **) addr) = optstring; break;
  1082.           case NumberArg:    *((int *) addr) = atoi(optstring); break;
  1083.           }
  1084. !         for (i = candidate->classcount; i > 0; --i)
  1085. !         (candidate++)->resource = NULL;
  1086.       }
  1087.   
  1088.   #ifndef X10
  1089.       if ((DISP = XOpenDisplay(display)) == NULL)
  1090. --- 2168,2202 ----
  1091.           case StringArg:    *((char **) addr) = optstring; break;
  1092.           case NumberArg:    *((int *) addr) = atoi(optstring); break;
  1093.           }
  1094. !         /* flag it for subsequent processing */
  1095. !         candidate->resource = (char *) candidate;
  1096.       }
  1097. +     /*
  1098. +      * Step 2.  Propagate classes for command line arguments.  Backwards.
  1099. +      */
  1100. +     for (opt = options + XtNumber(options) - 1; opt >= options; --opt)
  1101. +         if (opt->resource == (char *) opt) {
  1102. +         addr = opt->address;
  1103. +         lastopt = opt + opt->classcount;
  1104. +         for (candidate = opt; candidate < lastopt; ++candidate) {
  1105. +             if (candidate->resource != NULL) {
  1106. +             switch (opt->argtype) {
  1107. +                 case BooleanArg:
  1108. +                 *((Boolean *) candidate->address) =
  1109. +                     *((Boolean *) addr);
  1110. +                 break;
  1111. +                 case StringArg:
  1112. +                 *((char **) candidate->address) =
  1113. +                     *((char **) addr);
  1114. +                 break;
  1115. +                 case NumberArg:
  1116. +                 *((int *) candidate->address) = *((int *) addr);
  1117. +                 break;
  1118. +             }
  1119. +             candidate->resource = NULL;
  1120. +             }
  1121. +         }
  1122. +         }
  1123.   
  1124.   #ifndef X10
  1125.       if ((DISP = XOpenDisplay(display)) == NULL)
  1126. ***************
  1127. *** 2132,2137 ****
  1128. --- 2206,2214 ----
  1129.       if (XOpenDisplay(display) == NULL)
  1130.           oops("Can't open display");
  1131.   #endif
  1132. +     /*
  1133. +      * Step 3.  Handle resources (including classes).
  1134. +      */
  1135.       for (opt = options; opt < options + XtNumber(options); ++opt)
  1136.           if (opt->resource &&
  1137.   #ifndef X10
  1138. ***************
  1139. *** 2140,2161 ****
  1140.   #else
  1141.               (optstring = XGetDefault(DPY prog, opt->resource)))
  1142.   #endif
  1143. !         switch (opt->argtype) {
  1144. !             case StringArg:
  1145. !             *((char **) opt->address) = optstring;
  1146. !             break;
  1147. !             case NumberArg:
  1148. !             *((int *) opt->address) = atoi(optstring);
  1149. !             break;
  1150. !             case BooleanArg:
  1151. !             *((Boolean *) opt->address) =
  1152. !                 (strcmp(optstring, "on") == 0);
  1153.           }
  1154. - 
  1155. -     if (!sidemargin) sidemargin = margins;
  1156. -     if (!topmargin) topmargin = margins;
  1157. -     if (!xoffset) xoffset = offsets;
  1158. -     if (!yoffset) yoffset = offsets;
  1159.   }
  1160.   
  1161.   #endif    /* TOOLKIT */
  1162. --- 2217,2237 ----
  1163.   #else
  1164.               (optstring = XGetDefault(DPY prog, opt->resource)))
  1165.   #endif
  1166. !         {
  1167. !             lastopt = opt + opt->classcount;
  1168. !             for (candidate = opt; candidate < lastopt; ++candidate)
  1169. !             if (candidate->resource != NULL) switch (opt->argtype) {
  1170. !                 case StringArg:
  1171. !                 *((char **) candidate->address) = optstring;
  1172. !                 break;
  1173. !                 case NumberArg:
  1174. !                 *((int *) candidate->address) = atoi(optstring);
  1175. !                 break;
  1176. !                 case BooleanArg:
  1177. !                 *((Boolean *) candidate->address) =
  1178. !                     (strcmp(optstring, "on") == 0);
  1179. !             }
  1180.           }
  1181.   }
  1182.   
  1183.   #endif    /* TOOLKIT */
  1184. ***************
  1185. *** 2382,2389 ****
  1186. --- 2458,2478 ----
  1187.           highGC = MakeGC(GXcopy, hl_Pixel, back_Pixel);
  1188.       }
  1189.   
  1190. + #ifndef    VMS
  1191.       ready_cursor = XCreateFontCursor(DISP, XC_cross);
  1192.       redraw_cursor = XCreateFontCursor(DISP, XC_watch);
  1193. + #else
  1194. +     DECWCursorFont = XLoadFont(DISP, "DECW$CURSOR");
  1195. +     XSetFont(DISP, foreGC, DECWCursorFont);
  1196. +     redraw_cursor = XCreateGlyphCursor(DISP, DECWCursorFont, DECWCursorFont,
  1197. +         decw$c_wait_cursor, decw$c_wait_cursor + 1,
  1198. +         &fore_color, &back_color);
  1199. +     MagnifyPixmap = XCreateBitmapFromData (DISP, RootWindowOfScreen(SCRN),
  1200. +         mag_glass_bits, mag_glass_width, mag_glass_height);
  1201. +     ready_cursor = XCreatePixmapCursor(DISP, MagnifyPixmap, MagnifyPixmap,
  1202. +         &back_color, &fore_color, mag_glass_x_hot, mag_glass_y_hot);
  1203. + #endif    /* VMS */
  1204. + 
  1205.       if (!curs_color)
  1206.           cr_Pixel = high_color ? hl_Pixel : fore_Pixel;
  1207.       {
  1208. ***************
  1209. *** 2637,2643 ****
  1210.   #endif    /* X10 */
  1211.   
  1212.       do_pages();
  1213. ! #ifdef    lint
  1214. !     return 0;
  1215. ! #endif
  1216.   }
  1217. --- 2726,2730 ----
  1218.   #endif    /* X10 */
  1219.   
  1220.       do_pages();
  1221. !     /* NOTREACHED */
  1222.   }
  1223. diff -cr old/xdvi.h new/xdvi.h
  1224. *** old/xdvi.h    Sun Oct 21 14:49:17 1990
  1225. --- new/xdvi.h    Tue Jan 15 15:17:41 1991
  1226. ***************
  1227. *** 135,141 ****
  1228.   extern    int    maxstack;
  1229.   extern    int    n_fonts_left;        /* for LRU management of fonts */
  1230.   extern    time_t    dvi_time;        /* last mod. time for dvi file */
  1231. - extern    char    *font_path;
  1232.   extern    int    page_w, page_h;
  1233.   
  1234.   /*
  1235. --- 135,140 ----
  1236. ***************
  1237. *** 145,153 ****
  1238.   extern    long    *page_offset;
  1239.   
  1240.   /*
  1241. !  * Mechanism for reducing repeated warning about specials.
  1242.    */
  1243. ! extern    Boolean    spec_warn, spec_warn_now;
  1244.   
  1245.   
  1246.   /*
  1247. --- 144,153 ----
  1248.   extern    long    *page_offset;
  1249.   
  1250.   /*
  1251. !  * Mechanism for reducing repeated warning about specials, lost characters, etc.
  1252.    */
  1253. ! extern    Boolean    hush_spec, hush_spec_now;
  1254. ! extern    Boolean    hush_chars;
  1255.   
  1256.   
  1257.   /*
  1258. ***************
  1259. *** 202,208 ****
  1260.       struct font *next;        /* link to next font info block */
  1261.       int TeXnumber;            /* font number (in DVI file) */
  1262.       int scale;            /* scaled size in SPELL units */
  1263. -     float factor;            /* multiply char. widths by this */
  1264.       char *fontname;            /* PXL file name */
  1265.       short size;            /* dots per 5 inches */
  1266.       FILE *file;            /* open PXL file or NULL */
  1267. --- 202,207 ----
  1268. diff -cr old/xdvi_man.sed new/xdvi_man.sed
  1269. *** old/xdvi_man.sed    Sun Oct 21 14:49:31 1990
  1270. --- new/xdvi_man.sed    Sat Feb  2 16:20:39 1991
  1271. ***************
  1272. *** 9,19 ****
  1273.   .B xdvi
  1274.   .nh
  1275.   [+[\fIpage\fP]] [\-s \fIshrink\fP] [\-S \fIdensity\fP] [\-p \fIpixels\fP] [\-l]
  1276. ! [\-sw] [\-paper \fIpapertype\fP] [\-mgs[\fIn\fP] \fIsize\fP]
  1277. ! [\-altfont \fIfont\fP]
  1278.   [\-margins \fIdimen\fP] [\-sidemargin \fIdimen\fP] [\-topmargin \fIdimen\fP]
  1279.   [\-offsets \fIdimen\fP] [\-xoffset \fIdimen\fP] [\-yoffset \fIdimen\fP]
  1280. ! [\-rv] [\-fg \fIcolor\fP] [\-bg \fIcolor\fP]
  1281.   [\-hl \fIcolor\fP] [\-bd \fIcolor\fP] [\-cr \fIcolor\fP] [\-bw \fIwidth\fP]
  1282.   #ifx11
  1283.   [\-geometry \fIgeometry\fP] [\-icongeometry \fIgeometry\fP] [\-iconic]
  1284. --- 9,19 ----
  1285.   .B xdvi
  1286.   .nh
  1287.   [+[\fIpage\fP]] [\-s \fIshrink\fP] [\-S \fIdensity\fP] [\-p \fIpixels\fP] [\-l]
  1288. ! [\-paper \fIpapertype\fP] [\-mgs[\fIn\fP] \fIsize\fP]
  1289. ! [\-hushspecials] [-hushchars] [-hush] [\-altfont \fIfont\fP]
  1290.   [\-margins \fIdimen\fP] [\-sidemargin \fIdimen\fP] [\-topmargin \fIdimen\fP]
  1291.   [\-offsets \fIdimen\fP] [\-xoffset \fIdimen\fP] [\-yoffset \fIdimen\fP]
  1292. ! [\-keep] [\-rv] [\-fg \fIcolor\fP] [\-bg \fIcolor\fP]
  1293.   [\-hl \fIcolor\fP] [\-bd \fIcolor\fP] [\-cr \fIcolor\fP] [\-bw \fIwidth\fP]
  1294.   #ifx11
  1295.   [\-geometry \fIgeometry\fP] [\-icongeometry \fIgeometry\fP] [\-iconic]
  1296. ***************
  1297. *** 94,105 ****
  1298.   (%%dot%%listFonts)
  1299.   Causes the names of the fonts used to be listed.
  1300.   .TP
  1301. ! .B \-sw
  1302. ! (%%dot%%specialWarn)
  1303. ! Causes \fIxdvi\fR to warn the user when it encounters a \\special string
  1304. ! which it cannot process.  This option is on by default; to turn it off,
  1305. ! use \fB+sw\fR.
  1306.   .TP
  1307.   .B \-rv
  1308.   (%%dot%%reverseVideo)
  1309.   Causes the page to be displayed with white characters on a
  1310. --- 94,113 ----
  1311.   (%%dot%%listFonts)
  1312.   Causes the names of the fonts used to be listed.
  1313.   .TP
  1314. ! .B \-hushspecials
  1315. ! (%%dot%%hushSpecials)
  1316. ! Causes \fIxdvi\fR to suppress warnings about \\special strings
  1317. ! which it cannot process.
  1318.   .TP
  1319. + .B \-hushchars
  1320. + (%%dot%%hushLostChars)
  1321. + Causes \fIxdvi\fR to suppress warnings about references to characters which
  1322. + are not defined in the font.
  1323. + .TP
  1324. + .B \-hush
  1325. + (%%dot%%Hush)
  1326. + Causes \fIxdvi\fR to suppress all suppressable warnings.
  1327. + .TP
  1328.   .B \-rv
  1329.   (%%dot%%reverseVideo)
  1330.   Causes the page to be displayed with white characters on a
  1331. ***************
  1332. *** 159,169 ****
  1333.   Always use the \fIcopy\fR operation when writing characters to the display.
  1334.   This option may be necessary for correct operation on a color display, but
  1335.   overstrike characters will be incorrect.
  1336.   #ifbuttons
  1337.   .TP
  1338.   .B \-expert
  1339.   (.expert)
  1340. ! Prevent the buttons from appearing.
  1341.   #endif
  1342.   .TP
  1343.   .BI \-margins " dimen"
  1344. --- 167,182 ----
  1345.   Always use the \fIcopy\fR operation when writing characters to the display.
  1346.   This option may be necessary for correct operation on a color display, but
  1347.   overstrike characters will be incorrect.
  1348. + .TP
  1349. + .B \-keep
  1350. + (.keepPosition)
  1351. + Sets a flag to indicate that \fIxdvi\fR should not move to the home position
  1352. + when moving to a new page.  See also the `k' keystroke.
  1353.   #ifbuttons
  1354.   .TP
  1355.   .B \-expert
  1356.   (.expert)
  1357. ! Prevent the buttons from appearing.  See also the `x' keystroke.
  1358.   #endif
  1359.   .TP
  1360.   .BI \-margins " dimen"
  1361. ***************
  1362. *** 345,359 ****
  1363.   of the same file while running \fIxdvi\fR only once.
  1364.   .TP
  1365.   .B k
  1366. ! Normally when \fIxdvi\fR switches pages it moves to the home position as well.
  1367.   The `k' keystroke toggles a `keep-position' flag which, when set, will keep
  1368.   the same position when moving between pages.  Also `0k' and `1k' clear and
  1369. ! set this flag, respectively.
  1370.   #ifbuttons
  1371.   .TP
  1372.   .B x
  1373.   Toggles expert mode (in which the buttons do not appear).  Also `0x' and `1x'
  1374. ! clear and reset this mode, respectively.
  1375.   #endif
  1376.   .SH MOUSE ACTIONS
  1377.   If the shrink factor is set to any number other than one, then clicking
  1378. --- 358,372 ----
  1379.   of the same file while running \fIxdvi\fR only once.
  1380.   .TP
  1381.   .B k
  1382. ! Normally when \fIxdvi\fR switches pages, it moves to the home position as well.
  1383.   The `k' keystroke toggles a `keep-position' flag which, when set, will keep
  1384.   the same position when moving between pages.  Also `0k' and `1k' clear and
  1385. ! set this flag, respectively.  See also the \fB\-keep\fR option.
  1386.   #ifbuttons
  1387.   .TP
  1388.   .B x
  1389.   Toggles expert mode (in which the buttons do not appear).  Also `0x' and `1x'
  1390. ! clear and reset this mode, respectively.  See also the \fB\-expert\fR option.
  1391.   #endif
  1392.   .SH MOUSE ACTIONS
  1393.   If the shrink factor is set to any number other than one, then clicking
  1394. ***************
  1395. *** 388,393 ****
  1396. --- 401,423 ----
  1397.   If the font cannot be found at all, then \fIxdvi\fR will try to vary the point
  1398.   size of the font (within a certain range), and if this fails, then it will
  1399.   use the font specified as the alternate font (cf. \fB-altfont\fR).
  1400. + .PP
  1401. + For compatibility with TeX, you may also use ``TEXFONTS'' in place of
  1402. + ``XDVIFONTS'', although in that case the variable should not include any
  1403. + ``%'' specifiers.
  1404. + #ifsubdir
  1405. + .PP
  1406. + You can also enable recursive searching in the font path by using the ``*''
  1407. + and ``**'' specifiers.  At this point in the path, \fIxdvi\fR will recursively
  1408. + search subdirectories of the given directory in order to find font files.
  1409. + A single asterisk limits the search to one level; a double asterisk will search
  1410. + through an arbitrary number of levels.  Also, the variable TEXFONTS_SUBDIR
  1411. + can be used to give a colon-separated list of directories to recursively search.
  1412. + This is equivalent to including the specifiers with a ``*'' after each; the
  1413. + usual conventions regarding extra colons applies here, too, relative to a
  1414. + default subdirectory path.  Asterisks may not be preceded by a ``%'' specifier
  1415. + in any path component.
  1416. + #endif
  1417.   .PP
  1418.   The ``XDVISIZES'' variable must be set to indicate which sizes of fonts are
  1419.   available.  It should consists of a list of numbers separated by colons.  If
  1420. --
  1421. Dan Heller
  1422. ------------------------------------------------
  1423. O'Reilly && Associates               Zyrcom Inc
  1424. Senior Writer                   President
  1425. argv@ora.com            argv@zipcode.com
  1426.